<html>
<head><meta charset="utf-8"><title>Building rustc with beta libstd · t-compiler · Zulip Chat Archive</title></head>
<h2>Stream: <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/index.html">t-compiler</a></h2>
<h3>Topic: <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html">Building rustc with beta libstd</a></h3>

<hr>

<base href="https://rust-lang.zulipchat.com">

<head><link href="https://rust-lang.github.io/zulip_archive/style.css" rel="stylesheet"></head>

<a name="209899890"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209899890" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209899890">(Sep 12 2020 at 21:03)</a>:</h4>
<p><span class="user-mention" data-user-id="116122">@simulacrum</span> do you think <code>build --stage 0 compiler/rustc</code> <em>without</em> depending on <code>build --stage 0 library/std</code> makes sense as a goal? And if so, do you mind if I open a tracking issue/MCP?</p>



<a name="209899943"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209899943" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209899943">(Sep 12 2020 at 21:04)</a>:</h4>
<p>that would cut down on compile times too (maybe not a ton, but significantly)</p>



<a name="209899948"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209899948" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209899948">(Sep 12 2020 at 21:04)</a>:</h4>
<p>It would cut compile times by like a minute or two?</p>



<a name="209899950"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209899950" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209899950">(Sep 12 2020 at 21:04)</a>:</h4>
<p>right</p>



<a name="209899952"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209899952" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209899952">(Sep 12 2020 at 21:05)</a>:</h4>
<p>At least for me building std takes less than a minute</p>



<a name="209899959"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209899959" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209899959">(Sep 12 2020 at 21:05)</a>:</h4>
<p>that's not the <em>primary</em> focus of doing this but it seems like an easy improvement</p>



<a name="209899965"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209899965" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209899965">(Sep 12 2020 at 21:05)</a>:</h4>
<p>(for some definition of easy)</p>



<a name="209899967"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209899967" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209899967">(Sep 12 2020 at 21:05)</a>:</h4>
<p>I don't think it's feasible though - we lose all of the advantages of rustc having a dependable std</p>



<a name="209900015"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900015" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900015">(Sep 12 2020 at 21:06)</a>:</h4>
<p>What do you mean by dependable std?</p>



<a name="209900019"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900019" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900019">(Sep 12 2020 at 21:06)</a>:</h4>
<p>Currently rustc only supports one std</p>



<a name="209900023"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900023" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900023">(Sep 12 2020 at 21:06)</a>:</h4>
<p>That's great, makes things much easier</p>



<a name="209900036"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900036" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900036">(Sep 12 2020 at 21:07)</a>:</h4>
<p>it sounds like you're talking about only supporting <em>building</em> one std</p>



<a name="209900047"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900047" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900047">(Sep 12 2020 at 21:07)</a>:</h4>
<p>and I want to be able to <em>use</em> (link to) beta std</p>



<a name="209900054"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900054" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900054">(Sep 12 2020 at 21:07)</a>:</h4>
<p>I agree being able to compile beta std with master rustc is a non-goal</p>



<a name="209900100"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900100" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900100">(Sep 12 2020 at 21:08)</a>:</h4>
<p>No, I'm saying that rustc only supports linking to one std and that makes things much easier because rustc can just immediately start using unstable features as they get added</p>



<a name="209900113"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900113" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900113">(Sep 12 2020 at 21:09)</a>:</h4>
<blockquote>
<p>rustc can just immediately start using unstable features as they get added</p>
</blockquote>
<p>that's nice, but is it worth the confusion and compile times? rustc can still use the features 6 weeks later on beta promotion</p>



<a name="209900116"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900116" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900116">(Sep 12 2020 at 21:09)</a>:</h4>
<p>Adding even more cfg bootstrap seems like a regression</p>



<a name="209900119"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900119" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900119">(Sep 12 2020 at 21:09)</a>:</h4>
<p>this is the same way that libstd can't depend on stage1 rustdoc and has to work with beta too</p>



<a name="209900121"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900121" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900121">(Sep 12 2020 at 21:09)</a>:</h4>
<p>And this proposal requires that</p>



<a name="209900122"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900122" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900122">(Sep 12 2020 at 21:09)</a>:</h4>
<p><span class="user-mention silent" data-user-id="116122">simulacrum</span> <a href="#narrow/stream/131828-t-compiler/topic/improving.20bootstrap.20times.20for.20contributor.20fun.20and.20profit/near/209900116">said</a>:</p>
<blockquote>
<p>Adding even more cfg bootstrap seems like a regression</p>
</blockquote>
<p>I'm proposing <em>less</em> cfg bootstrap</p>



<a name="209900129"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900129" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900129">(Sep 12 2020 at 21:09)</a>:</h4>
<p>like, after 1.48 gets promoted and you remove all the cfgs, just never adding them back</p>



<a name="209900134"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900134" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900134">(Sep 12 2020 at 21:10)</a>:</h4>
<p>No, or at least I don't see how. Both std and rustc will be full of cfg bootstrap</p>



<a name="209900185"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900185" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900185">(Sep 12 2020 at 21:10)</a>:</h4>
<p>let me say this a little differently maybe</p>



<a name="209900195"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900195" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900195">(Sep 12 2020 at 21:11)</a>:</h4>
<p>the reason cfg(bootstrap) has to exist at all is because rustc and std interact with each other, right? they have to have the same lang items, builtin macros, and so on</p>



<a name="209900197"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900197" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900197">(Sep 12 2020 at 21:11)</a>:</h4>
<p>in stage 0 the compiler would link to beta std, in stage 1 to master std, ergo, you end up with cfg(bootstrap) in the compiler</p>



<a name="209900199"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900199" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900199">(Sep 12 2020 at 21:11)</a>:</h4>
<p>that's the <em>current reason</em></p>



<a name="209900200"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900200" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900200">(Sep 12 2020 at 21:11)</a>:</h4>
<p>but if we end up with rustc linking to different stds, you gain another reason -- the thing you're using in std has changed APIs</p>



<a name="209900241"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900241" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900241">(Sep 12 2020 at 21:12)</a>:</h4>
<p>currently when that change happens we just update the compiler and we're good</p>



<a name="209900250"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900250" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900250">(Sep 12 2020 at 21:12)</a>:</h4>
<p>but here we'd need to maintain two copies, one using old API and one using new API</p>



<a name="209900251"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900251" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900251">(Sep 12 2020 at 21:12)</a>:</h4>
<p><span class="user-mention silent" data-user-id="116122">simulacrum</span> <a href="#narrow/stream/131828-t-compiler/topic/improving.20bootstrap.20times.20for.20contributor.20fun.20and.20profit/near/209900200">said</a>:</p>
<blockquote>
<p>but if we end up with rustc linking to different stds, you gain another reason -- the thing you're using in std has changed APIs</p>
</blockquote>
<p>not if it doesn't use unstable features! that's the really big change I'm proposing, is not <em>needing</em> to use any APIs that might change</p>



<a name="209900258"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900258" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900258">(Sep 12 2020 at 21:12)</a>:</h4>
<p>which maybe is not super feasible right now</p>



<a name="209900261"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900261" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900261">(Sep 12 2020 at 21:12)</a>:</h4>
<p>IMO saying "rustc does not use unstable libs features" is not going to fly right now</p>



<a name="209900276"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900276" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900276">(Sep 12 2020 at 21:13)</a>:</h4>
<p>like, at that point we might as well push for compiler being a stable-compatible tool, which sure, is <em>feasible</em> to do eventually, but I think not right now, and maybe shouldn't be a goal</p>



<a name="209900282"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900282" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900282">(Sep 12 2020 at 21:13)</a>:</h4>
<p>even with aggressively bumped MSRV</p>



<a name="209900330"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900330" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900330">(Sep 12 2020 at 21:14)</a>:</h4>
<p>that said, there should be no reason to actually want this</p>



<a name="209900332"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900332" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900332">(Sep 12 2020 at 21:14)</a>:</h4>
<p>in practice the solution to fast local builds is just "bring your own master std"</p>



<a name="209900337"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900337" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900337">(Sep 12 2020 at 21:14)</a>:</h4>
<p>(and master compiler)</p>



<a name="209900346"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900346" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900346">(Sep 12 2020 at 21:15)</a>:</h4>
<p>which means rebasing -&gt; re-download compiler + std, but that's not horrible</p>



<a name="209900352"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900352" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900352">(Sep 12 2020 at 21:15)</a>:</h4>
<p>and we could maybe get away with just redownloading std with some interesting gymnastics</p>



<a name="209900393"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900393" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900393">(Sep 12 2020 at 21:16)</a>:</h4>
<p>so, I agree this might be more work than it's worth right now, <em>but</em> one of the other benefits to this is no more <code>cfg(bootstrap)</code> in libstd: it <em>only</em> has to compile with master rustc, not with beta</p>



<a name="209900399"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900399" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900399">(Sep 12 2020 at 21:16)</a>:</h4>
<p>since you no longer need it for compiling rustc itself</p>



<a name="209900418"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900418" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900418">(Sep 12 2020 at 21:17)</a>:</h4>
<p>since I'm not volunteering to put in the work ;) I'm fine with saying 'the project doesn't have time for this right now', but does this make sense as a goal?</p>



<a name="209900455"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900455" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900455">(Sep 12 2020 at 21:18)</a>:</h4>
<p>it would be a lot simpler than the current situation IMO</p>



<a name="209900489"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900489" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900489">(Sep 12 2020 at 21:18)</a>:</h4>
<p>cc <span class="user-mention" data-user-id="133169">@matklad</span> btw, it's your blog post that sparked all this <span aria-label="big smile" class="emoji emoji-1f604" role="img" title="big smile">:big_smile:</span></p>



<a name="209900654"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900654" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900654">(Sep 12 2020 at 21:22)</a>:</h4>
<p>I don't think it makes sense personally</p>



<a name="209900664"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900664" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900664">(Sep 12 2020 at 21:23)</a>:</h4>
<p>cfg(bootstrap) is much easier to understand in std than in rustc, IMO, because in std it's usually basically "this function/impl" doesn't exist</p>



<a name="209900671"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900671" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900671">(Sep 12 2020 at 21:23)</a>:</h4>
<p>vs. "in the middle of complicated logic, there are now two copies of a function call doing some sort of interesting algorithmic detail"</p>



<a name="209900716"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900716" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900716">(Sep 12 2020 at 21:24)</a>:</h4>
<p>The end goal is 'no cfg(bootstrap)', not 'move cfg(bootstrap) to rustc', I agree the second is definitely not worth it</p>



<a name="209900735"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900735" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900735">(Sep 12 2020 at 21:25)</a>:</h4>
<p>Anyway, maybe this is just idle speculation</p>



<a name="209900742"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900742" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900742">(Sep 12 2020 at 21:25)</a>:</h4>
<p>I think the x.py changes are more likely to make things easier in the short term</p>



<a name="209900744"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900744" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900744">(Sep 12 2020 at 21:25)</a>:</h4>
<p>That end goal is only feasible with "rustc compiles on stable" I think</p>



<a name="209900797"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900797" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900797">(Sep 12 2020 at 21:26)</a>:</h4>
<p>and though that's true-ish already today -- rustc can't use new language features -- rustc <em>can</em> use library features and that's helpful</p>



<a name="209900804"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900804" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900804">(Sep 12 2020 at 21:26)</a>:</h4>
<p>the dogfooding with library features and older language features has historically been really useful</p>



<a name="209900875"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900875" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900875">(Sep 12 2020 at 21:28)</a>:</h4>
<p>It would still be possible to dogfood, you'd just have to wait 6 weeks</p>



<a name="209900889"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900889" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900889">(Sep 12 2020 at 21:29)</a>:</h4>
<p>sure, I guess</p>



<a name="209900896"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900896" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900896">(Sep 12 2020 at 21:29)</a>:</h4>
<p>I'm not at all proposing that we remove RUSTC_BOOTSTRAP</p>



<a name="209900897"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900897" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900897">(Sep 12 2020 at 21:29)</a>:</h4>
<p>but not if you wanted to avoid:</p>
<blockquote>
<p>vs. "in the middle of complicated logic, there are now two copies of a function call doing some sort of interesting algorithmic detail"</p>
</blockquote>



<a name="209900951"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900951" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900951">(Sep 12 2020 at 21:30)</a>:</h4>
<p>maybe I'm over promoting that point, I don't know how often it would happen in practice</p>



<a name="209900961"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209900961" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209900961">(Sep 12 2020 at 21:30)</a>:</h4>
<p>I'm not sure how that would come up if rustc compiled with beta</p>



<a name="209901031"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209901031" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209901031">(Sep 12 2020 at 21:32)</a>:</h4>
<p>well, you'd have something like:</p>
<div class="codehilite"><pre><span></span><code>// ...
#[cfg(bootstrap)]
vec.retain(|x| x != y);
#[cfg(not(bootstrap))]
vec.drain_filter(|x| x == y);
//...
</code></pre></div>



<a name="209901034"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209901034" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209901034">(Sep 12 2020 at 21:32)</a>:</h4>
<p>Oh I see - I was suggesting to just not have the second version</p>



<a name="209901039"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209901039" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209901039">(Sep 12 2020 at 21:32)</a>:</h4>
<p>I mean if the API changed... you have no choice?</p>



<a name="209901043"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209901043" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209901043">(Sep 12 2020 at 21:32)</a>:</h4>
<p>because you need to compile with beta std and master std</p>



<a name="209901047"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209901047" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209901047">(Sep 12 2020 at 21:33)</a>:</h4>
<p>Right, <code>retain</code> would work with both</p>



<a name="209901127"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209901127" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209901127">(Sep 12 2020 at 21:35)</a>:</h4>
<p>And if you want to keep dogfooding, then wait to use drain_filter until beta has it (which it does currently)</p>



<a name="209901164"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209901164" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209901164">(Sep 12 2020 at 21:38)</a>:</h4>
<p>let me clarify: I don't think rustc needs to compile on stable, I think it would be nice to compile on beta <em>with RUSTC_BOOTSTRAP</em></p>



<a name="209901167"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209901167" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209901167">(Sep 12 2020 at 21:38)</a>:</h4>
<p>which still allows using unstable features as long as they made the last beta cutoff</p>



<a name="209901534"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209901534" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> cuviper <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209901534">(Sep 12 2020 at 21:55)</a>:</h4>
<p>distro flag -- sometimes we don't have the previous rustc/std available, as we're rebuilding the current version of the package</p>



<a name="209901574"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209901574" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> cuviper <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209901574">(Sep 12 2020 at 21:56)</a>:</h4>
<p>so "compiler always uses beta std" (or N-1) doesn't work</p>



<a name="209901591"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209901591" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> cuviper <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209901591">(Sep 12 2020 at 21:57)</a>:</h4>
<p>if an unstable API changes between N-1 and N, rustc has to compile either way</p>



<a name="209902862"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209902862" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209902862">(Sep 12 2020 at 22:34)</a>:</h4>
<p><span class="user-mention silent" data-user-id="138448">cuviper</span> <a href="#narrow/stream/131828-t-compiler/topic/improving.20bootstrap.20times.20for.20contributor.20fun.20and.20profit/near/209901591">said</a>:</p>
<blockquote>
<p>if an unstable API changes between N-1 and N, rustc has to compile either way</p>
</blockquote>
<p>stage1 builds stage2, so CI would catch that anyway</p>



<a name="209902868"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209902868" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209902868">(Sep 12 2020 at 22:34)</a>:</h4>
<p>but that's a good point there could be changes in the unstable API - maybe have a policy that unstable features go through a release of deprecation before being removed?</p>



<a name="209902870"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209902870" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209902870">(Sep 12 2020 at 22:34)</a>:</h4>
<p>that seems like a good policy anyway</p>



<a name="209903274"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209903274" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209903274">(Sep 12 2020 at 22:48)</a>:</h4>
<p>also, could someone split this into a separate topic starting from around <a href="#narrow/stream/131828-t-compiler/topic/improving.20bootstrap.20times.20for.20contributor.20fun.20and.20profit/near/209899890">https://rust-lang.zulipchat.com/#narrow/stream/131828-t-compiler/topic/improving.20bootstrap.20times.20for.20contributor.20fun.20and.20profit/near/209899890</a> ? maybe named 'building rustc from beta libstd'</p>



<a name="209903281"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209903281" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209903281">(Sep 12 2020 at 22:49)</a>:</h4>
<p>oh it turns out I can do it haha</p>



<a name="209904294"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209904294" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209904294">(Sep 12 2020 at 23:20)</a>:</h4>
<p>I don't think we can afford to impose changes like that on all unstable features at this stage of development, they're way too high cost</p>



<a name="209904355"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209904355" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209904355">(Sep 12 2020 at 23:22)</a>:</h4>
<p>well, maybe we could switch the compiler to use a different (stable) API if one it's using gets changed</p>



<a name="209904365"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209904365" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209904365">(Sep 12 2020 at 23:22)</a>:</h4>
<p>these are changes in the standard library so they shouldn't be too hard to work around</p>



<a name="209904368"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209904368" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209904368">(Sep 12 2020 at 23:22)</a>:</h4>
<p>Especially considering you win maybe a minute or two of time at most, and that after a rebase. And a good bit of that time can be shaved off if we invested in faster std builds more than we do now</p>



<a name="209904378"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209904378" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209904378">(Sep 12 2020 at 23:23)</a>:</h4>
<p>the main benefit I see is not really the lower compile times, but having a simpler model of x.py and being able to get rid of <code>cfg(bootstrap)</code></p>



<a name="209904380"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209904380" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209904380">(Sep 12 2020 at 23:23)</a>:</h4>
<p>and like matklad mentioned in the post, maybe being able to <code>cargo build</code> rustc itself some day</p>



<a name="209904382"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209904382" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209904382">(Sep 12 2020 at 23:23)</a>:</h4>
<p>I think the cost of what you suggest to standard library and compiler development is way too high</p>



<a name="209904422"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209904422" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209904422">(Sep 12 2020 at 23:24)</a>:</h4>
<p>You can already cargo build rustc, in theory, on latest master</p>



<a name="209905724"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209905724" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> scottmcm <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209905724">(Sep 13 2020 at 00:01)</a>:</h4>
<p>FWIW, when I was on a slow CPU, the time to build stage0 std was nowhere close to my big problem.  Now part of that was I'd use <code>--keep-stage 0</code> when changing just core/alloc/std, which I hear some people say I shouldn't, but it always worked perfectly for me.</p>



<a name="209906141"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209906141" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209906141">(Sep 13 2020 at 00:13)</a>:</h4>
<blockquote>
<p>part of that was I'd use --keep-stage 0</p>
</blockquote>
<p>another thing this would help is modifying libstd would no longer need to rebuild the whole compiler</p>



<a name="209906148"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209906148" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209906148">(Sep 13 2020 at 00:13)</a>:</h4>
<p>only <code>--stage 1 library/std</code>, and it would be sound unlike --keep-stage</p>



<a name="209906191"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209906191" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209906191">(Sep 13 2020 at 00:14)</a>:</h4>
<p><span class="user-mention silent" data-user-id="116122">simulacrum</span> <a href="#narrow/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd/near/209904422">said</a>:</p>
<blockquote>
<p>You can already cargo build rustc, in theory, on latest master</p>
</blockquote>
<p>I tried this (<code>cargo check</code> in the top-level directory) and got 190 errors about things not being Sized <span aria-label="shrug" class="emoji emoji-1f937" role="img" title="shrug">:shrug:</span></p>



<a name="209906334"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209906334" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209906334">(Sep 13 2020 at 00:19)</a>:</h4>
<p>oh interesting, <code>cargo check</code> in <code>compiler/rustc</code> seems to be working though</p>



<a name="209906343"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209906343" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209906343">(Sep 13 2020 at 00:19)</a>:</h4>
<p>well, if I set <code>CFG_RELEASE</code>, <code>CFG_RELEASE_CHANNEL</code>, and <code>RUSTC_INSTALL_BINDIR</code></p>



<a name="209907337"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209907337" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209907337">(Sep 13 2020 at 00:50)</a>:</h4>
<p>Sized errors are just compiler being overeager, probably - it's likely really the duplicate lang items or lack of any definition or something like that</p>



<a name="209931464"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209931464" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> matklad <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209931464">(Sep 13 2020 at 13:27)</a>:</h4>
<p>We are trying to synchronize the disscussion in <a href="https://hackmd.io/u-kT-u6PS0aGUls_7A-fUQ">https://hackmd.io/u-kT-u6PS0aGUls_7A-fUQ</a></p>



<a name="209939997"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209939997" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> RalfJ <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209939997">(Sep 13 2020 at 17:04)</a>:</h4>
<blockquote>
<p>that's nice, but is it worth the confusion and compile times? rustc can still use the features 6 weeks later on beta promotion</p>
</blockquote>
<p>which confusion? and if it's about 60s of compile time <em>once</em> (as libstd does not get rebuilt when you just change rustc), then -- yes it is definitely worth it, with my regular compiler contributor hat on.</p>
<blockquote>
<p>so, I agree this might be more work than it's worth right now, but one of the other benefits to this is no more cfg(bootstrap) in libstd: it only has to compile with master rustc, not with beta</p>
</blockquote>
<p>I dont think that's true though. libstd has to still build with both beta and nightly rustc, so cfg(bootstrap) is still needed for any new lang item, new intrinsic, lint change, using a new lang feature (unless we want to wait 6 weeks before using it, which will slow down development <em>a lot</em> as we often notice problems when starting to actually use features), lang feature stabilization, ... (all the same things where it is needed now). your proposal makes it so that cfg(bootstrap) is needed <em>both</em> in libstd and rustc, instead of just in libstd like now.</p>



<a name="209940509"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209940509" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Lokathor <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209940509">(Sep 13 2020 at 17:16)</a>:</h4>
<p>I'm deeply anti compile time, but if we're talking about +1 minute in a build that's already <strong>tens</strong> of minutes long, probably keep things simpler and eat the extra minute. If it gets to the point where the average user has a 5 minute build and we could make it a 4 minute build, <em>then</em> consider again.</p>



<a name="209941152"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209941152" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209941152">(Sep 13 2020 at 17:31)</a>:</h4>
<p><a href="https://github.com/rust-lang/rust/pull/49119">https://github.com/rust-lang/rust/pull/49119</a> is a past effort at doing this, I think, which received mostly positive feedback (but also seems to not address the downsides we've noted here?)</p>



<a name="209941724"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209941724" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209941724">(Sep 13 2020 at 17:45)</a>:</h4>
<p>That changes wasn't removing <code>cfg(bootstrap)</code> from libstd</p>



<a name="209941731"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209941731" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209941731">(Sep 13 2020 at 17:45)</a>:</h4>
<p>So it had a different set of tradeoffs</p>



<a name="209941779"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209941779" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209941779">(Sep 13 2020 at 17:46)</a>:</h4>
<p>Maybe those were better trade-offs? Having stage0 rustc not depend on stage0 libstd still seems useful</p>



<a name="209942556"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209942556" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209942556">(Sep 13 2020 at 18:04)</a>:</h4>
<blockquote>
<p>If we're talking about +1 minute in a build that's already <strong>tens</strong> of minutes long, probably keep things simpe and eat the extra minute</p>
</blockquote>
<p>Again, my primary motivation is <em>not</em> the compile times, but removing the need for <code>--keep-stage 0</code> and simplifying the bootstrap model</p>



<a name="209942560"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209942560" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209942560">(Sep 13 2020 at 18:04)</a>:</h4>
<p>But maybe that's not worth the tradeoffs <span aria-label="shrug" class="emoji emoji-1f937" role="img" title="shrug">:shrug:</span></p>



<a name="209943395"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209943395" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Dylan MacKenzie (ecstatic-morse) <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209943395">(Sep 13 2020 at 18:24)</a>:</h4>
<p>"Low information voter" here <span aria-label="smile" class="emoji emoji-1f642" role="img" title="smile">:smile:</span>. One of the stated goals in the hackMD is removing <code>cfg(bootstrap)</code>, but it seems like the proposed change would just move it into <code>rustc</code>. Why is this better? There's an "important note" that seems to allude to some mitigating factors, but I don't really understand it.</p>



<a name="209943486"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209943486" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209943486">(Sep 13 2020 at 18:27)</a>:</h4>
<p>there are two different discussions going on, one about moving rustc to stable and one about moving it to beta libstd</p>



<a name="209943496"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209943496" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209943496">(Sep 13 2020 at 18:27)</a>:</h4>
<p>oh wait no the threads diverged again ahhh too much discussion <span aria-label="see no evil" class="emoji emoji-1f648" role="img" title="see no evil">:see_no_evil:</span></p>



<a name="209943510"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209943510" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209943510">(Sep 13 2020 at 18:27)</a>:</h4>
<p>there are <em>three</em> different discussions going on <span aria-label="laughing" class="emoji emoji-1f606" role="img" title="laughing">:laughing:</span></p>



<a name="209943579"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209943579" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209943579">(Sep 13 2020 at 18:28)</a>:</h4>
<ol>
<li>Should rustc compile on stable?</li>
<li>Should rustc compile on beta using beta libstd? (right now it uses beta with master libstd)</li>
<li>Should libstd compile with beta? (right now it does)</li>
</ol>



<a name="209943593"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209943593" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209943593">(Sep 13 2020 at 18:28)</a>:</h4>
<p>only changing 3 allows removing <code>cfg(bootstrap)</code>, but it requires first having 2</p>



<a name="209943612"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209943612" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209943612">(Sep 13 2020 at 18:30)</a>:</h4>
<p>but.. (2) means introducing cfg(bootstrap) into rustc, unless its expanded to "Should rustc compile on beta using beta libstd, by removing unstable libs feature use?"</p>



<a name="209943651"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209943651" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209943651">(Sep 13 2020 at 18:30)</a>:</h4>
<p>sure</p>



<a name="209943656"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209943656" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209943656">(Sep 13 2020 at 18:30)</a>:</h4>
<p>anyway, I'm not convinced anymore this is the right change</p>



<a name="209943663"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209943663" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209943663">(Sep 13 2020 at 18:30)</a>:</h4>
<p>maybe <span class="user-mention" data-user-id="133169">@matklad</span> has different opinions</p>



<a name="209943670"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209943670" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209943670">(Sep 13 2020 at 18:30)</a>:</h4>
<p>I just mean that there's no way to remove cfg(bootstrap) that I've seen so far that isn't "rustc just works on stable entirely"</p>



<a name="209943689"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209943689" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209943689">(Sep 13 2020 at 18:31)</a>:</h4>
<blockquote>
<p>Bad: #[cfg(bootstrap)] is hard to understand, using beta compiler and master libstd is mind-bending (even some members of the compiler team were not aware this was the case)</p>
</blockquote>
<p>I also would like someone to elaborate on this, because both cfg(bootstrap) and the beta compiler+master std seem pretty reasonable/intuitive to me. Could someone who finds this mind-bending try to elaborate on why that is? (Maybe examples or something)?</p>



<a name="209943742"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209943742" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209943742">(Sep 13 2020 at 18:32)</a>:</h4>
<p>like, not being aware of something and still being able to function as a compiler team member seems great, not a bad thing</p>



<a name="209943747"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209943747" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209943747">(Sep 13 2020 at 18:32)</a>:</h4>
<p>we shouldn't expect everyone to know/understand every detail of the bootstrapping processs</p>



<a name="209943748"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209943748" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209943748">(Sep 13 2020 at 18:32)</a>:</h4>
<p>I've seen confusion about <code>cfg(bootstrap)</code> a few times</p>



<a name="209943761"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209943761" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209943761">(Sep 13 2020 at 18:33)</a>:</h4>
<p><span class="user-mention" data-user-id="216206">@lcnr</span> I think I have too, but without concrete examples I don't think we can work out strategies that'll address it</p>



<a name="209943782"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209943782" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209943782">(Sep 13 2020 at 18:33)</a>:</h4>
<p>I do think that this can be (and has been <span aria-label="sparkles" class="emoji emoji-2728" role="img" title="sparkles">:sparkles:</span> ) improved using better documentation and tools, but we can never reduce the mental burden to nothing here</p>



<a name="209943838"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209943838" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209943838">(Sep 13 2020 at 18:34)</a>:</h4>
<p>well, beyond the "just works on stable", but I think we have broad agreement that we're not ready for that</p>



<a name="209943865"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209943865" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Dylan MacKenzie (ecstatic-morse) <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209943865">(Sep 13 2020 at 18:35)</a>:</h4>
<p>When you say "stable", do you mean "latest beta with nightly features enabled" or something else?</p>



<a name="209943912"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209943912" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209943912">(Sep 13 2020 at 18:36)</a>:</h4>
<p>well, "beta without nightly features"</p>



<a name="209943928"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209943928" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209943928">(Sep 13 2020 at 18:36)</a>:</h4>
<p>nighty features once again require <code>cfg(bootstrap)</code> if they change on master</p>



<a name="209943929"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209943929" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209943929">(Sep 13 2020 at 18:37)</a>:</h4>
<p>(so just super-aggressive MSRV, essentially)</p>



<a name="209943943"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209943943" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Dylan MacKenzie (ecstatic-morse) <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209943943">(Sep 13 2020 at 18:37)</a>:</h4>
<p>But that's mostly a strawman proposal?</p>



<a name="209943954"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209943954" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Dylan MacKenzie (ecstatic-morse) <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209943954">(Sep 13 2020 at 18:37)</a>:</h4>
<p>I think I'll check back in when things settle down a bit <span aria-label="smile" class="emoji emoji-1f642" role="img" title="smile">:smile:</span></p>



<a name="209944007"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209944007" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Dylan MacKenzie (ecstatic-morse) <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209944007">(Sep 13 2020 at 18:38)</a>:</h4>
<p>/me retreats into apocalypse-proof bunker</p>



<a name="209944020"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209944020" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209944020">(Sep 13 2020 at 18:39)</a>:</h4>
<p>/me joins <span class="user-mention silent" data-user-id="118594">ecstatic-morse</span></p>



<a name="209944039"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209944039" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Dylan MacKenzie (ecstatic-morse) <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209944039">(Sep 13 2020 at 18:39)</a>:</h4>
<p><span class="user-mention" data-user-id="232545">@Joshua Nelson</span> There's enough food for three weeks. After that, we have a difficult conversation.</p>



<a name="209944130"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209944130" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Léo Lanteri Thauvin <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209944130">(Sep 13 2020 at 18:41)</a>:</h4>
<p>What's "three weeks"?</p>



<a name="209944138"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209944138" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Léo Lanteri Thauvin <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209944138">(Sep 13 2020 at 18:41)</a>:</h4>
<p>Ah, yes, half a release cycle</p>



<a name="209944508"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209944508" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> matklad <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209944508">(Sep 13 2020 at 18:50)</a>:</h4>
<blockquote>
<p>I dont think that's true though. libstd has to still build with both beta and nightly rustc</p>
</blockquote>
<p><span class="user-mention" data-user-id="120791">@RalfJ</span>  I think this need not to be the case. We can require that only master rustc can compile master libstd (this has tradeoffs, but is doable).</p>



<a name="209945208"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209945208" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> matklad <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209945208">(Sep 13 2020 at 19:06)</a>:</h4>
<blockquote>
<p>maybe @matklad has different opinions</p>
</blockquote>
<p>I am pretty sure I am not qualified to have a heavy-weight opinion here, I'd personally trust <span class="user-mention silent" data-user-id="116122">simulacrum</span> 's opinion more than mine :-)</p>
<p>That said, I do believe "rustc is just a standard crate"  is conceptually right, and that n-order benefits of this setup would be substantional. I believe that the current setup is incompatible with that, and should be changed. </p>
<p>I see two ways to make a "just a crate rustc": a) build rustc with beta stdlib b) implement cargo feature to allow building <em>any</em> crate with custom stdlib. Among the two, a) seems to be conceptually right.</p>
<p>I do think "no more <code>cfg(bootstrap)</code> in stdlib" of <code>a</code> is a significant (100) benefit. (The fact that me, <span class="user-mention silent" data-user-id="120791">RalfJ</span> and <span class="user-mention silent" data-user-id="216206">lcnr</span> can't agree on whether it is removable in theory is a good example of confusion).</p>
<p>I do think that delaying the usage of unstable library features by 6 weeks is a significant drawback (-80), which we already face for language features anyway.</p>
<p>I agree that "changing a nightly library feature which is used in the compiler" would require some busy work, but I don't think the scale of this problem would be large (-10): this work needs to be done only for features which actually change, and, although compiler uses a lot of lib features in total, I think any particular feature is not used <em>that</em> much, and it shouldn't be a problem to write the code without a nightly library feature for a specific feature for transition period.</p>



<a name="209970237"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209970237" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jubilee <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209970237">(Sep 14 2020 at 06:55)</a>:</h4>
<p>Obligatory note that for every 1 person who complains audibly that x.py is frustratingly opaque to them, there's at least 10 other dev corpses who never survived to the point of posting a complaint. :^)</p>



<a name="209971465"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209971465" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> RalfJ <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209971465">(Sep 14 2020 at 07:14)</a>:</h4>
<p>well and there's also all those for whom it works fine so they see no need to speak up^^</p>



<a name="209971742"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209971742" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> RalfJ <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209971742">(Sep 14 2020 at 07:19)</a>:</h4>
<blockquote>
<p>That said, I do believe "rustc is just a standard crate" is conceptually right, and that n-order benefits of this setup would be substantional. I believe that the current setup is incompatible with that, and should be changed. </p>
</blockquote>
<p>The hackMD talks about "as if the compiler was written in Go", but IMO that misses the point. If the Rust compiler was written in Go, <em>it would use the Go standard library</em>, not the Rust one. Our standard library plays double-duty as the standard library for the compiler and the standard library for code compiled by the compiler. So it is only natural that these standard libraries differ a bit, which is reflected by <code>cfg(bootstrap)</code>.<br>
The "imagine rustc was written in a different language" proposal is essentially equivalent to having a standard library with a top-level</p>
<div class="codehilite"><pre><span></span><code><span class="cp">#[cfg(bootstrap)]</span><span class="w"></span>
<span class="k">use</span><span class="w"> </span><span class="n">std_for_compiler</span>::<span class="o">*</span><span class="p">;</span><span class="w"></span>
<span class="cp">#[cfg(not(bootstrap))]</span><span class="w"></span>
<span class="k">use</span><span class="w"> </span><span class="n">std_for_ecosystem</span>::<span class="o">*</span><span class="p">;</span><span class="w"></span>
</code></pre></div>


<p>So, even in that view, <code>cfg(bootstrap)</code> is not avoided, quite the contrary.</p>
<p>Also, there is something fundamentally recursive that happens when a compiler compiles itself. It <em>is</em> mind-bending, but the only way to avoid that is to indeed write the compiler in a different language, which has way more drawbacks than advantages (for a language like Rust). I don't understand how that's even listed as a desirable goal.^^<br>
So, I do not think it is possible to have a self-hosting compiler without some amount of "mind-bending", and I think the proposals here just move the mind-bending around while also making compiler development much more painful than it is right now.</p>



<a name="209972087"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209972087" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> RalfJ <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209972087">(Sep 14 2020 at 07:24)</a>:</h4>
<p>To give an example for what works fairly well right now: I plan to submit a PR that stabilizes <code>union</code> with <code>ManuallyDrop&lt;T&gt;</code> fields. In the same PR I want to be sure that this actually works and is useful, so besides a few tests, I will remove the <code>untagged_union</code> feature from library/ and compiler/ and make everything compile again. Of course the beta compiler still trets this as unstable, so this will require <code>cfg(bootstrap)</code>.<br>
I am fairly strongly opposed to any proposal that would force me to split this PR into two (so when I do the stabilization I have much lower confidence that everything actually works as intended), and -- even worse -- to let 6 weeks pass between these two PRs (so I need to keep track of doing this somewhere, making sure I do not forget -- I already have more than enough things to keep track of).</p>
<p>I don't think bootstrapping with <code>cfg(bootstrap)</code> is hard enough to understand that the few people that actually have to interact with it cannot be taught, with some proper documentation. Removing cfg(bootstrap)  (if it can be done) will make contribution easier for some but harder for others -- but the "some" just need to learn less while for the "others", some of what they did becomes impossible (using a new language/library feature immediately). So overall IMO this makes rustc a much less attractive codebase to hack on.<br>
Of course, I am biased since I am one of the "others". ;)</p>



<a name="209972424"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209972424" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> RalfJ <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209972424">(Sep 14 2020 at 07:28)</a>:</h4>
<p>OTOH, y'all seem convinced that what I think is impossible can actually be achieved, so I guess -- don't let me stop you, I'll wait until there is a concrete proposal and then I'll comment on that. ;)</p>



<a name="209977468"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/209977468" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> matklad <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#209977468">(Sep 14 2020 at 08:31)</a>:</h4>
<blockquote>
<p>I am fairly strongly opposed to any proposal that would force me to split this PR into two </p>
</blockquote>
<p>I don't see why you would need to split the PR in two in this case.<code>#![feature(untagged_unions)]</code> is used only in <code>/library</code>, so, in my proposal, you just remove it without adding <code>cfg(bootstrap)</code> anywhere.</p>



<a name="210031532"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210031532" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> RalfJ <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210031532">(Sep 14 2020 at 16:42)</a>:</h4>
<p>ah because you think you can make it so that library/ is not built by the bootstrap compiler, just by nightly... I see. interesting.</p>



<a name="210203741"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210203741" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Ahmed Charles <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210203741">(Sep 15 2020 at 23:17)</a>:</h4>
<p>The <code>std_for_compiler</code> and <code>std_for_ecosystem</code> above would be related in the sense that <code>std_for_ecosystem</code> is a backwards compatible, drop in replacement for <code>std_for_compiler</code> when used to build the compiler. That's that same as saying <code>rustc</code> builds on stable, effectively. Clang/LLVM have this restriction primarily because they support compiling without a bootstrap phase with 3 or more other C++ compilers, GCC/Clang/MSVC. If Rust had multiple viable compilers written in Rust, I imagine the second compiler would be designed to 'compile on stable', simply because the alternative wouldn't be feasible.</p>



<a name="210204334"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210204334" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Ahmed Charles <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210204334">(Sep 15 2020 at 23:24)</a>:</h4>
<p>Perhaps my opinion isn't worth much, but perhaps it's useful when considering that it's a possible 'outsider' opinion. I've previously hacked on clang and rustc. When rust was pre 1.0, I took the bootstrap process as a cool novelty in it's recursive nature. But I also assumed that when 1.0 came around, surely the compiler would migrate to being built on stable, especially after years of stabilizing more and more features. I guess I'm not sure why one needs the equivalent of <code>Option::zip</code> while writing the compiler rather than just writing:</p>
<div class="codehilite"><pre><span></span><code>    pub fn unstable_option_zip_free_function&lt;T, U&gt;(this: Option&lt;T&gt;, other: Option&lt;U&gt;) -&gt; Option&lt;(T, U)&gt; {
        match (this, other) {
            (Some(a), Some(b)) =&gt; Some((a, b)),
            _ =&gt; None,
        }
    }
</code></pre></div>



<a name="210204478"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210204478" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Ahmed Charles <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210204478">(Sep 15 2020 at 23:26)</a>:</h4>
<p>And in that sense, contributing to clang meant that I wrote an implementation of <code>std::make_unique</code> because the code couldn't rely on the standard library having it, but it also meant only ever having to do one compile cycle and never hearing the word bootstrap.</p>



<a name="210210838"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210210838" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> est31 <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210210838">(Sep 16 2020 at 00:52)</a>:</h4>
<p><span class="user-mention silent" data-user-id="120791">RalfJ</span> <a href="#narrow/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd/near/209972087">said</a>:</p>
<blockquote>
<p>I am fairly strongly opposed to any proposal that would force me to split this PR into two (so when I do the stabilization I have much lower confidence that everything actually works as intended), and -- even worse -- to let 6 weeks pass between these two PRs (so I need to keep track of doing this somewhere, making sure I do not forget -- I already have more than enough things to keep track of)</p>
</blockquote>
<p>One could think about adding FIXME's to the code that automatically ping people when the bootstrap compiler is updated.</p>



<a name="210211005"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210211005" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> est31 <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210211005">(Sep 16 2020 at 00:55)</a>:</h4>
<p>Also, isn't there a lint already that warns if you use a stable <code>#![feature(..)]</code>? One could think about adding customizability to warn if you use a feature that's been stable since N releases</p>



<a name="210211177"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210211177" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> est31 <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210211177">(Sep 16 2020 at 00:58)</a>:</h4>
<p>As for the "to make sure it's working" point, most lang features aren't used by std, so it's apparently not very important. If it is, then one should think about better ways/policies for testing stabilizations.</p>



<a name="210243595"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210243595" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> matklad <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210243595">(Sep 16 2020 at 10:26)</a>:</h4>
<blockquote>
<p>ah because you think you can make it so that library/ is not built by the bootstrap compiler, just by nightly... I see. interesting.</p>
</blockquote>
<p>Yesssss! I am glad we are on the same page, I was fearing I was bugging you all with my crazy ideas without understanding something crucial :)</p>
<p>To be clear, I am not going to use this as a leverage for my proposal (as I am not sure myself if it's good), I am just glad about resolving misunderstanding.</p>



<a name="210251411"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210251411" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> RalfJ <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210251411">(Sep 16 2020 at 12:05)</a>:</h4>
<blockquote>
<p>ah because you think you can make it so that library/ is not built by the bootstrap compiler, just by nightly... I see. interesting.</p>
</blockquote>
<p>so won't one consequence of that be that it will be <em>harder</em> to hack on the library because you cannot use the bootstrap compiler for that?<br>
I guess you could do something like rustup-toolchain-install-master or so... is that the plan?</p>



<a name="210266259"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210266259" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> matklad <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210266259">(Sep 16 2020 at 14:06)</a>:</h4>
<p>Yes, it would be harder. </p>
<p>In the ideal world, where building the compiler is reasonable, and not a giant pita, just using some magical <code>rust-toolchain</code> which points at master would work OK I think. </p>
<p>In today's world, requiring to build the compiler to hack on stdlib would be a giant regression. But requiring to use the latest nightly probably won't be that bad. </p>
<p>More details in <a href="https://hackmd.io/u-kT-u6PS0aGUls_7A-fUQ">https://hackmd.io/u-kT-u6PS0aGUls_7A-fUQ</a></p>



<a name="210277776"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210277776" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Ahmed Charles <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210277776">(Sep 16 2020 at 15:21)</a>:</h4>
<p>Technically, if all unstable features/lang items used by std were stabilized, then building std with stable would be doable and would only require a sufficiently recent stable compiler/core combination. Not that it's a goal but it certainly seems plausible in the long term.</p>



<a name="210277851"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210277851" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jonas Schievink  [he/him] <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210277851">(Sep 16 2020 at 15:21)</a>:</h4>
<p>lang items will never be stabilized, they are an implementation detail of rustc</p>



<a name="210278246"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210278246" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jonas Schievink  [he/him] <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210278246">(Sep 16 2020 at 15:24)</a>:</h4>
<p>Not that it matters much, a <code>rust-toolchain</code> file makes working with nightly projects very painless</p>



<a name="210282541"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210282541" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Ahmed Charles <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210282541">(Sep 16 2020 at 15:55)</a>:</h4>
<p>Ah... I thought <code>#[global_allocator]</code> was an example of a lang_item which was stabilized, but perhaps my understanding of the terms is confused.</p>



<a name="210282666"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210282666" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Ahmed Charles <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210282666">(Sep 16 2020 at 15:56)</a>:</h4>
<p>Same with <code>#[panic_handler]</code>.</p>



<a name="210282776"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210282776" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Ahmed Charles <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210282776">(Sep 16 2020 at 15:57)</a>:</h4>
<p>The ones that are intended to not be stable are likely ones which are in core, hence why I didn't mention being able to build core with stable, only std.</p>



<a name="210282928"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210282928" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Ahmed Charles <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210282928">(Sep 16 2020 at 15:58)</a>:</h4>
<p>And I'm not sure what <code>rust-toolchain</code> is but typing <code>cargo +nightly build</code> isn't the painful part of working with nightly projects.</p>



<a name="210300740"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210300740" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> scottmcm <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210300740">(Sep 16 2020 at 18:23)</a>:</h4>
<p><span class="user-mention" data-user-id="336395">@Ahmed Charles</span> <code>core</code> will, I think, always fundamentally always use unstable things.  And if one cannot build <code>core</code> on stable, I'm not sure it's all that helpful for <code>std</code> to be able to be built on stable, since I would expect them to generally be built by the same process.</p>



<a name="210332360"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210332360" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Noah Lev <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210332360">(Sep 16 2020 at 23:29)</a>:</h4>
<p>And <code>std</code> depends on <code>core</code>, so you would need to build them with the same toolchain, right?</p>



<a name="210332387"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210332387" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210332387">(Sep 16 2020 at 23:29)</a>:</h4>
<p>yes</p>



<a name="210339961"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210339961" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Ahmed Charles <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210339961">(Sep 17 2020 at 01:44)</a>:</h4>
<p>Just to clarify, my point was:</p>
<ol>
<li>In a world where <code>#[cfg(bootstrap)]</code> doesn't exist.</li>
<li>And <code>std</code> doesn't itself contain unstable features or lang items.</li>
<li>Building <code>std</code> on master wouldn't require building the <code>rustc</code> on master first, it would be sufficient to download stable on rustup and build/test <code>std</code> using it.</li>
</ol>
<p>Note, the requirement that <code>core</code> and <code>std</code> be built by the same toolchain holds. As for <code>core</code> and <code>std</code> being built by the same 'process', the notion of process is vague enough that I don't know how to respond.</p>



<a name="210340046"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210340046" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210340046">(Sep 17 2020 at 01:46)</a>:</h4>
<blockquote>
<p>And std doesn't itself contain unstable features or lang items.</p>
</blockquote>
<p>I don't think this makes sense really</p>



<a name="210340125"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210340125" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210340125">(Sep 17 2020 at 01:48)</a>:</h4>
<p>here's an example of 'never stabilized features' libstd uses (by the very rough criteria 'attribute that starts with <code>rustc_</code>'):</p>
<div class="codehilite"><pre><span></span><code>#[rustc_allocator]
#[rustc_allocator_nounwind]
#[rustc_allow_const_fn_ptr]
#[rustc_args_required_const
#[rustc_builtin_macro]
#[rustc_const_stable
#[rustc_const_unstable
#[rustc_conversion_suggestion]
#[rustc_deprecated
#[rustc_diagnostic_item
#[rustc_force_min_const_fn]`
#[rustc_inherit_overflow_checks]
#[rustc_layout_scalar_valid_range_start
#[rustc_macro_transparency
#[rustc_nonnull_optimization_guaranteed]
#[rustc_on_unimplemented
#[rustc_paren_sugar]
#[rustc_promotable]
#[rustc_reservation_impl
#[rustc_specialization_trait]
#[rustc_std_internal_symbol]
#[rustc_unsafe_specialization_marker]
</code></pre></div>



<a name="210340142"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210340142" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210340142">(Sep 17 2020 at 01:49)</a>:</h4>
<p>the standard library would be worse without these, but I don't think it's clear in most cases that the ecosystem would be better with them</p>



<a name="210340167"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210340167" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210340167">(Sep 17 2020 at 01:50)</a>:</h4>
<p>and lang_items are basically necessary if you want <code>core</code> to be usable separate from <code>alloc</code> due to coherence</p>



<a name="210340219"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210340219" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Mario Carneiro <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210340219">(Sep 17 2020 at 01:50)</a>:</h4>
<p>I would be interested to see a rundown/analysis of each of these features and the rationale for keeping them unstable or keeping them in std</p>



<a name="210340225"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210340225" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210340225">(Sep 17 2020 at 01:50)</a>:</h4>
<p>anyway I <em>strongly</em> request that we separate the goals of 'building on stable' and 'building with RUSTC_BOOTSTRAP and beta libstd'</p>



<a name="210340234"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210340234" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210340234">(Sep 17 2020 at 01:51)</a>:</h4>
<p>the stream for 'building on stable' is <a href="#narrow/stream/233931-t-compiler.2Fmajor-changes/topic/MCP.3A.20move.20compiler.2F.20crates.20to.20stable.20Rust.20compiler-team.23358">https://rust-lang.zulipchat.com/#narrow/stream/233931-t-compiler.2Fmajor-changes/topic/MCP.3A.20move.20compiler.2F.20crates.20to.20stable.20Rust.20compiler-team.23358</a></p>



<a name="210343700"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210343700" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Mario Carneiro <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210343700">(Sep 17 2020 at 03:05)</a>:</h4>
<p><span class="user-mention silent" data-user-id="120791">RalfJ</span> <a href="#narrow/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd/near/209972087">said</a>:</p>
<blockquote>
<p>To give an example for what works fairly well right now: I plan to submit a PR that stabilizes <code>union</code> with <code>ManuallyDrop&lt;T&gt;</code> fields. In the same PR I want to be sure that this actually works and is useful, so besides a few tests, I will remove the <code>untagged_union</code> feature from library/ and compiler/ and make everything compile again. Of course the beta compiler still trets this as unstable, so this will require <code>cfg(bootstrap)</code>.<br>
I am fairly strongly opposed to any proposal that would force me to split this PR into two (so when I do the stabilization I have much lower confidence that everything actually works as intended), and -- even worse -- to let 6 weeks pass between these two PRs (so I need to keep track of doing this somewhere, making sure I do not forget -- I already have more than enough things to keep track of).</p>
</blockquote>
<p>(Warning: outsider opinion) Here is a setup that is used in other projects I have worked on: We have a compiler <code>A</code> that compiles standard library <code>B</code>. Both change continuously, but <code>B.1.n</code> (master) compiles with compiler <code>A.1</code> (beta), while at the same time <code>B.1.next</code> (release branch) compiles with <code>A.1.m</code> (master). When the compiler releases a new version, <code>A.1.m</code> becomes <code>A.2</code> and <code>B.1.next</code> becomes <code>B.2</code>.</p>
<p>Rust has it a bit more complicated because of the bootstrapping, but it seems like you can still do the same thing the other way. <code>A.1.n</code> compiles on <code>B.1</code>, and you have a feature branch <code>A.1.next</code> tracking either <code>B.1.m</code> or <code>B.1.next</code> (hopefully there is no difference here, or you are probably being more mind bending than you need to be).</p>
<p>Applied to your example, that means that you put the <code>#[feature(...)]</code> removal on the release branch, which accumulates with all changes that have been made since the last beta.</p>



<a name="210481716"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210481716" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> est31 <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210481716">(Sep 18 2020 at 06:06)</a>:</h4>
<p>Note that the "nightly std only adds a minute of additional compile time" argument is wrong. The moment you change the tiniest part of std, <em>all</em> stage0 artifacts are recompiled, both from <a href="http://crates.io">crates.io</a> and from the local checkout. So rebasing prs means you have to do a full build now if there has been any change in std since. The build could have been much cheaper. Flags like <code>--keep-stage</code> are great but not easily discoverable, also didn't get it to work for myself. I said <code>--keep-stage 1</code>, changed std, hit recompile and it happily started compilation of stage0 std again...</p>



<a name="210486156"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210486156" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> bjorn3 <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210486156">(Sep 18 2020 at 07:22)</a>:</h4>
<p>You need <code>--keep-stage 0</code>.</p>



<a name="210507548"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210507548" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> RalfJ <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210507548">(Sep 18 2020 at 11:46)</a>:</h4>
<p><span class="user-mention" data-user-id="271719">@Mario Carneiro</span> I don't entirely understand the naming you are using, but it sounds like my example would still involve separate PRs to multiple branches? The release branch (<code>beta</code>) is only changed for critical bugfixes so not sure how that would all work with Rust.</p>



<a name="210526023"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210526023" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Mario Carneiro <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210526023">(Sep 18 2020 at 14:26)</a>:</h4>
<p><span class="user-mention" data-user-id="120791">@RalfJ</span>  When I say "release branch" above, <code>B.1.next</code>, I mean the "release-directed" branch that accumulates all the compatibility changes that have been made so far in the <code>A.1.m</code> master branch. What I mean by this is that you imagine a bunch of commits happening on master as A.1.1, A.1.2, ... while the beta <code>A.1</code> is the more-stable version (the 6 weeks release in rust's case). With every commit that breaks the library, a parallel fixup commit is made to the standard library on the <code>B.1.next</code> branch, which  is not otherwise used "in production", so that all upcoming breakage is fixed in advance without touching the "production" master version of the standard library B.1.1, B.1.2, ... which compiles with the last major release of the compiler. <code>B.1.next</code> is not versioned but you would normally keep it up to date with changes to the compiler (always) and changes to the standard library (as necessary), but only contains bugfixes, no features.</p>



<a name="210526504"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210526504" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Mario Carneiro <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210526504">(Sep 18 2020 at 14:29)</a>:</h4>
<p>In lean's nomenclature, A.1.n would be the compiler nightly, A.1 would be the beta version, and similarly B.1.n and B.1 are the nightly resp. beta versions of the standard library. My contention is that there is no analogue of A.1.next (the nightly plays double duty in this role) and this is the source of some problems wrt over-frequent bootstrapping.</p>



<a name="210530103"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210530103" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> RalfJ <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210530103">(Sep 18 2020 at 14:53)</a>:</h4>
<p>I still dont understand what this "A/B.x.y" syntax means, and whether "next", "n" and "m" are to be interpreted literally or as representing some integer... but you seem to say that the alternative you describe involves spreading development across two branches (A.1.next and something else), which seems like a worse situation to me than what rustc is doing.</p>



<a name="210530783"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210530783" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> RalfJ <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210530783">(Sep 18 2020 at 14:57)</a>:</h4>
<p>The rustc repo is fully self-contained in terms of specifying what exactly it takes to bootstrap this compiler (the beta binaries requried for this are stored out-of-tree because having binaries in git is a bad idea, but the git repo says exactly which binary you need). That's a very important feature IMO, for all sorts of reasons from reproducible CI to deterministic builds to ease of development.</p>



<a name="210531072"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210531072" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Mario Carneiro <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210531072">(Sep 18 2020 at 14:59)</a>:</h4>
<p>In the situation I am more familiar with, A and B are separate repositories. (Doing that for rust though is an entirely separate discussion.) Here  <code>n</code> and <code>m</code> are variables ranging over integers, patch level version numbers</p>



<a name="210531565"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210531565" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Mario Carneiro <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210531565">(Sep 18 2020 at 15:02)</a>:</h4>
<p>So you might have A.1 being like Rust 1.46 and then a bunch of mini versions A.1.1, A.1.2 (I don't know if these have names in rust besides just git commits) as master evolves, then you cut the next release A.2. A.1.next (you could call it literally this or some other name if you prefer) is a branch of the repo that tracks changes in dependencies; when you cut a new release you make sure A.1.next is up to date with master (or at least the parts of it you want to release) as well as all dependencies and then rename it to A.2</p>



<a name="210532163"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210532163" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Mario Carneiro <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210532163">(Sep 18 2020 at 15:06)</a>:</h4>
<p><span class="user-mention silent" data-user-id="120791">RalfJ</span> <a href="#narrow/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd/near/210530783">said</a>:</p>
<blockquote>
<p>The rustc repo is fully self-contained in terms of specifying what exactly it takes to bootstrap this compiler (the beta binaries requried for this are stored out-of-tree because having binaries in git is a bad idea, but the git repo says exactly which binary you need). That's a very important feature IMO, for all sorts of reasons from reproducible CI to deterministic builds to ease of development.</p>
</blockquote>
<p>I'm not sure why precise bootstrapping of master branch subversions is considered important. Why not just limit the bootstrap to major versions? Otherwise you don't have any isolation from instability in dependencies, causing a lot more churn than is necessary</p>



<a name="210532300"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210532300" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210532300">(Sep 18 2020 at 15:07)</a>:</h4>
<p>we only technically support bootstrapping from a particular beta for each commit on master</p>



<a name="210532321"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210532321" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210532321">(Sep 18 2020 at 15:07)</a>:</h4>
<p>I don't think Ralf said otherwise?</p>



<a name="210532325"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210532325" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Mario Carneiro <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210532325">(Sep 18 2020 at 15:07)</a>:</h4>
<p>That said, it is probably possible to simultaneously support a precise bootstrap and the more relaxed bootstrap I'm suggesting. I'm not totally clear on how rust does it but I think this is already the case</p>



<a name="210532581"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210532581" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Mario Carneiro <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210532581">(Sep 18 2020 at 15:09)</a>:</h4>
<p>I think a general decoupling of rustc and std is a good thing. There are many things to bikeshed about the details there though</p>



<a name="210532718"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210532718" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210532718">(Sep 18 2020 at 15:10)</a>:</h4>
<p>I would not necessarily characterize it as a bikeshed. Those details are <em>really important</em> IMO.</p>



<a name="210532782"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210532782" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210532782">(Sep 18 2020 at 15:10)</a>:</h4>
<p><span class="user-mention silent" data-user-id="271719">Mario Carneiro</span> <a href="#narrow/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd/near/210532581">said</a>:</p>
<blockquote>
<p>I think a general decoupling of rustc and std is a good thing.</p>
</blockquote>
<p>I'm not sure how feasible that is :/</p>



<a name="210532821"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210532821" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210532821">(Sep 18 2020 at 15:11)</a>:</h4>
<p>my original proposal didn't decouple libstd from rustc at all, only rustc from libstd</p>



<a name="210533008"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210533008" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210533008">(Sep 18 2020 at 15:12)</a>:</h4>
<p>FWIW glibc does this too - it has <em>tons</em> of <code>#ifdef __GNUC__</code> everywhere</p>



<a name="210533035"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210533035" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210533035">(Sep 18 2020 at 15:12)</a>:</h4>
<p>so it can behave differently when compiled with gcc</p>



<a name="210533172"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210533172" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Mario Carneiro <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210533172">(Sep 18 2020 at 15:13)</a>:</h4>
<p>For a bit of context, my "day job" is on the lean theorem prover, which also has a large standard library called mathlib. Both projects are worked on by the same people and have very high incompatibility rates w.r.t earlier versions, so I deal with this problem on a pretty regular basis. The main difference with rust is that it's not bootstrapped</p>



<a name="210533476"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210533476" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Mario Carneiro <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210533476">(Sep 18 2020 at 15:15)</a>:</h4>
<p>They are actually in separate repositories, which has some consequences re: not being able to PR simultaneously to both</p>



<a name="210533553"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210533553" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Mario Carneiro <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210533553">(Sep 18 2020 at 15:15)</a>:</h4>
<p>which is part of why we settled on a "release cycle" of the sort I've described</p>



<a name="210534048"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/Building%20rustc%20with%20beta%20libstd/near/210534048" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Mario Carneiro <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/Building.20rustc.20with.20beta.20libstd.html#210534048">(Sep 18 2020 at 15:17)</a>:</h4>
<p>when everything is in one repo there is no bound your incompatibility rate. This is good for agility but means recompiles are more frequent than desirable (especially important if compiles are expensive, as in rust's case)</p>



<hr><p>Last updated: Aug 07 2021 at 22:04 UTC</p>
</html>